# -*- coding: utf-8 -*-

#    Copyright (C) 2005-2012 2011 by Promotux
#                       di Francesco Meloni snc - http://www.promotux.it/

#    Author: Francesco Meloni  <francesco@promotux.it>
#    This file is part of Promogest.

#    Promogest is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 2 of the License, or
#    (at your option) any later version.

#    Promogest is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.

#    You should have received a copy of the GNU General Public License
#    along with Promogest.  If not, see <http://www.gnu.org/licenses/>.


from sqlalchemy import *
from sqlalchemy.orm import *
from promogest.Environment import *
from promogest.dao.Dao import Dao, Base
from promogest.dao.DaoUtils import *
from promogest.lib.utils import *
from promogest.dao.Cliente import Cliente
from promogest.dao.Articolo import Articolo
from promogest.modules.GestioneCommesse.dao.StadioCommessa import StadioCommessa
from promogest.modules.GestioneCommesse.dao.RigaCommessa import RigaCommessa


class TestataCommessa(Dao, Base):

    try:
        __table__ = Table('testata_commessa',
                          params['metadata'],
                          schema=params['schema'],
                          autoload=True)
    except:
        from data.testataCommessa import t_testata_commessa
        __table__ = t_testata_commessa

    righe_commessa = relationship("RigaCommessa", primaryjoin=(__table__.c.id == RigaCommessa.id_testata_commessa))
    cli = relationship("Cliente", primaryjoin=__table__.c.id_cliente == Cliente.id)
    art = relationship("Articolo", primaryjoin=__table__.c.id_articolo == Articolo.id)
    st_com = relationship("StadioCommessa", primaryjoin=__table__.c.id_stadio_commessa == StadioCommessa.id)


    def __init__(self, req=None):
        Dao.__init__(self, entity=self)
        self.__righeCommessa = []
        self.__dbRigheCommessa= []

    @reconstructor
    def init_on_load(self):
        self.__righeCommessa = []
        self.__dbRigheCommessa = []

    def _getRigheCommessa(self):
        self.__dbRigheCommessa = self.righe_commessa
        self.__righeCommessa = self.__dbRigheCommessa[:]
        return self.__righeCommessa

    def _setRigheCommessa(self, value):
        self.__righeCommessa = value

    righecommessa = property(_getRigheCommessa, _setRigheCommessa)

    def ultimaCommessa(self):
        a = select([func.max(TestataCommessa.c.data_fine)]).execute().fetchall()
        if a:
            return a[0][0]
        else:
            return None

    @property
    def cliente(self):
        """ esempio di funzione  unita alla property """
        # cli = Cliente().getRecord(id=self.id_cliente)
        if self.cli:
            return self.cli.ragione_sociale
        else:
            return ""

    @property
    def articolo(self):
        """ esempio di funzione  unita alla property """
        if self.art:
            return self.art.codice + " " + self.art.denominazione
        else:
            return ""

    @property
    def stadio_commessa(self):
        """ esempio di funzione  unita alla property """
        if self.st_com:
            return self.st_com.denominazione
        else:
            return ""

    def filter_values(self, k, v):
        if k == 'daNumero':
            dic = {k: TestataCommessa.numero >= v}
        elif k == 'aNumero':
            dic = {k: TestataCommessa.numero <= v}
        elif k == 'datafinecheck':
            dic = {k: TestataCommessa.data_fine == None}
        elif k == 'datafine':
            dic = {k: TestataCommessa.data_fine == v}
        elif k == 'numero':
            dic = {k: TestataCommessa.numero == v}
        elif k == 'daDataInizio':
            dic = {k: TestataCommessa.data_inizio >= v}
        elif k == 'aDataInizio':
            dic = {k: TestataCommessa.data_inizio <= v}
        elif k == 'daDataFine':
            dic = {k: TestataCommessa.data_fine >= v}
        elif k== 'aDataFine':
            dic = {k: TestataCommessa.data_fine <= v}
        elif k == 'idStadioCommessa':
            dic = {k: TestataCommessa.id_stadio_commessa==v}
        elif k == 'denominazione':
            dic = {k: TestataCommessa.denominazione.ilike("%"+v+"%")}
        return dic[k]

    def righeCommessaDel(self,id=None):
        """ Cancella le righe associate ad una cmmessa
        """
        if self.righe_commessa:
            for r in self.righe_commessa:
                params['session'].delete(r)
            params["session"].commit()
        return True

    def delete(self):
        row = RigaCommessa().select(idTestataCommessa=self.id,
                                    offset=None,
                                    batchSize=None)
        if row:
            for r in row:
                params['session'].delete(r)
                params["session"].commit()
        params['session'].delete(self)
        params["session"].commit()

    def persist(self):
        """ cancellazione righe associate alla testata """
        params["session"].add(self)
        params["session"].commit()
        if self.__righeCommessa:
            for riga in self.__righeCommessa:
                riga.id_testata_commessa = self.id
                riga.persist()
        self.__righeCommessa = []
